home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / cpu / s2650 / 2650dasm.c next >
C/C++ Source or Header  |  2000-05-04  |  21KB  |  831 lines
  1. /***************************************************************************
  2.  *
  3.  *    Portable Signetics 2650 disassembler
  4.  *
  5.  *    Written by J. Buchmueller (pullmoll@t-online.de)
  6.  *    for the MAME project
  7.  *
  8.  **************************************************************************/
  9.  
  10. #include <stdio.h>
  11. #include "memory.h"
  12.  
  13. /* Set this to 1 to disassemble using Z80 style mnemonics */
  14. #define HJB     1
  15.  
  16. /* Set this to 1 to give names to condition codes and flag bits */
  17. #define MNEMO   1
  18.  
  19. /* handy table to build relative offsets from HR (holding register) */
  20. static int rel[0x100] = {
  21.       0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
  22.      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  23.      32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  24.      48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  25.     -64,-63,-62,-61,-60,-59,-58,-57,-56,-55,-54,-53,-52,-51,-50,-49,
  26.     -48,-47,-46,-45,-44,-43,-42,-41,-40,-39,-38,-37,-36,-35,-34,-33,
  27.     -32,-31,-30,-29,-28,-27,-26,-25,-24,-23,-22,-21,-20,-19,-18,-17,
  28.     -16,-15,-14,-13,-12,-11,-10, -9, -8, -7, -6, -5, -4, -3, -2, -1,
  29.       0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
  30.      16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
  31.      32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
  32.      48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
  33.     -64,-63,-62,-61,-60,-59,-58,-57,-56,-55,-54,-53,-52,-51,-50,-49,
  34.     -48,-47,-46,-45,-44,-43,-42,-41,-40,-39,-38,-37,-36,-35,-34,-33,
  35.     -32,-31,-30,-29,-28,-27,-26,-25,-24,-23,-22,-21,-20,-19,-18,-17,
  36.     -16,-15,-14,-13,-12,-11,-10, -9, -8, -7, -6, -5, -4, -3, -2, -1,
  37. };
  38.  
  39. typedef char* (*callback) (int addr);
  40. static callback find_symbol = 0;
  41.  
  42. static char *SYM(int addr)
  43. {
  44.     static char buff[8+1];
  45.     char * s = NULL;
  46.  
  47.     if (find_symbol) s = (*find_symbol)(addr);
  48.     if (s) return s;
  49.  
  50.     sprintf(buff, "$%04x", addr);
  51.     return buff;
  52. }
  53.  
  54. /* format an immediate */
  55. static char *IMM(int pc)
  56. {
  57.     static char buff[32];
  58.  
  59.     sprintf(buff, "$%02x", cpu_readop_arg(pc));
  60.     return buff;
  61. }
  62.  
  63. #if MNEMO
  64. static    char cc[4] = { 'z', 'p', 'm', 'a' };
  65.  
  66. /* format an immediate for PSL */
  67. static char *IMM_PSL(int pc)
  68. {
  69.     static char buff[32];
  70.     char *p = buff;
  71.     int v = cpu_readop_arg(pc);
  72.  
  73.     if (v == 0xff) {
  74.         p += sprintf(p, "all");
  75.     } else {
  76.         switch (v & 0xc0)
  77.         {
  78.             case 0x40: p += sprintf(p, "p+"); break;
  79.             case 0x80: p += sprintf(p, "m+"); break;
  80.             case 0xc0: p += sprintf(p, "cc+"); break;
  81.         }
  82.         if (v & 0x20)    /* inter digit carry */
  83.             p += sprintf(p, "idc+");
  84.         if (v & 0x10)    /* register select */
  85.             p += sprintf(p, "rs+");
  86.         if (v & 0x08)    /* with carry */
  87.             p += sprintf(p, "wc+");
  88.         if (v & 0x04)    /* overflow */
  89.             p += sprintf(p, "ovf+");
  90.         if (v & 0x02)    /* 2's complement comparisons */
  91.             p += sprintf(p, "com+");
  92.         if (v & 0x01)    /* carry */
  93.             p += sprintf(p, "c+");
  94.         if (p > buff)
  95.             *--p = '\0';
  96.     }
  97.     return buff;
  98. }
  99.  
  100. /* format an immediate for PSU (processor status upper) */
  101. static char *IMM_PSU(int pc)
  102. {
  103.     static char buff[32];
  104.     char *p = buff;
  105.     int v = cpu_readop_arg(pc);
  106.  
  107.     if (v == 0xff) {
  108.  
  109.         p += sprintf(p, "all");
  110.  
  111.     } else {
  112.  
  113.         if (v & 0x80)   /* sign */
  114.             p += sprintf(p, "m+");
  115.         if (v & 0x40)
  116.             p += sprintf(p, "p+");
  117.         if (v & 0x20)    /* interrupt inhibit */
  118.             p += sprintf(p, "ii+");
  119.         if (v & 0x10)    /* unused bit 4 */
  120.             p += sprintf(p, "4+");
  121.         if (v & 0x08)    /* unused bit 3 */
  122.             p += sprintf(p, "3+");
  123.         if (v & 0x04)    /* stack pointer bit 2 */
  124.             p += sprintf(p, "sp2+");
  125.         if (v & 0x02)    /* stack pointer bit 1 */
  126.             p += sprintf(p, "sp1+");
  127.         if (v & 0x01)    /* stack pointer bit 0 */
  128.             p += sprintf(p, "sp0+");
  129.         if (p > buff)
  130.             *--p = '\0';
  131.     }
  132.     return buff;
  133. }
  134. #else
  135. static    char cc[4] = { '0', '1', '2', '3' };
  136. #define IMM_PSL IMM
  137. #define IMM_PSU IMM
  138. #endif
  139.  
  140. /* format an relative address */
  141. static char *REL(int pc)
  142. {
  143. static char buff[32];
  144. int o = cpu_readop_arg(pc);
  145.     sprintf(buff, "%s%s", (o&0x80)?"*":"", SYM((pc&0x6000)+((pc+1+rel[o])&0x1fff)));
  146.     return buff;
  147. }
  148.  
  149. /* format an relative address (implicit page 0) */
  150. static char *REL0(int pc)
  151. {
  152. static char buff[32];
  153. int o = cpu_readop_arg(pc);
  154.     sprintf(buff, "%s%s", (o&0x80)?"*":"", SYM((rel[o]) & 0x1fff));
  155.     return buff;
  156. }
  157.  
  158. /* format a destination register and an absolute address */
  159. static char *ABS(int load, int r, int pc)
  160. {
  161.     static char buff[32];
  162.     int h = cpu_readop_arg(pc);
  163.     int l = cpu_readop_arg((pc&0x6000)+((pc+1)&0x1fff));
  164.     int a = (pc & 0x6000) + ((h & 0x1f) << 8) + l;
  165.  
  166. #if HJB
  167.     if (load) {
  168.         switch (h >> 5) {
  169.             case 0: sprintf(buff, "r%d,(%s)",       r, SYM(a)); break;
  170.             case 1: sprintf(buff, "r0,(%s,r%d++)",  SYM(a), r); break;
  171.             case 2: sprintf(buff, "r0,(%s,r%d--)",  SYM(a), r); break;
  172.             case 3: sprintf(buff, "r0,(%s,r%d)",    SYM(a), r); break;
  173.             case 4: sprintf(buff, "r%d,*(%s)",      r, SYM(a)); break;
  174.             case 5: sprintf(buff, "r0,*(%s,r%d++)", SYM(a), r); break;
  175.             case 6: sprintf(buff, "r0,*(%s,r%d--)", SYM(a), r); break;
  176.             case 7: sprintf(buff, "r0,*(%s,r%d)",   SYM(a), r); break;
  177.         }
  178.     } else {
  179.         switch (h >> 5) {
  180.             case 0: sprintf(buff, "(%s),r%d",       SYM(a), r); break;
  181.             case 1: sprintf(buff, "(%s,r%d++),r0",  SYM(a), r); break;
  182.             case 2: sprintf(buff, "(%s,r%d--),r0",  SYM(a), r); break;
  183.             case 3: sprintf(buff, "(%s,r%d),r0",    SYM(a), r); break;
  184.             case 4: sprintf(buff, "*(%s),r%d",      SYM(a), r); break;
  185.             case 5: sprintf(buff, "*(%s,r%d++),r0", SYM(a), r); break;
  186.             case 6: sprintf(buff, "*(%s,r%d--),r0", SYM(a), r); break;
  187.             case 7: sprintf(buff, "*(%s,r%d),r0",   SYM(a), r); break;
  188.         }
  189.     }
  190. #else
  191.     switch (h >> 5) {
  192.         case 0: sprintf(buff, "%d %s",      r, SYM(a)); break;
  193.         case 1: sprintf(buff, "0 %s,r%d+",  SYM(a), r); break;
  194.         case 2: sprintf(buff, "0 %s,r%d-",  SYM(a), r); break;
  195.         case 3: sprintf(buff, "0 %s,r%d",   SYM(a), r); break;
  196.         case 4: sprintf(buff, "%d *%s",     r, SYM(a)); break;
  197.         case 5: sprintf(buff, "0 *%s,r%d+", SYM(a), r); break;
  198.         case 6: sprintf(buff, "0 *%s,r%d-", SYM(a), r); break;
  199.         case 7: sprintf(buff, "0 *%s,r%d",  SYM(a), r); break;
  200.     }
  201. #endif
  202.     return buff;
  203. }
  204.  
  205. /* format an (branch) absolute address */
  206. static char *ADR(int pc)
  207. {
  208.     static char buff[32];
  209.     int h = cpu_readop_arg(pc);
  210.     int l = cpu_readop_arg((pc&0x6000)+((pc+1)&0x1fff));
  211.     int a = ((h & 0x7f) << 8) + l;
  212.     if (h & 0x80)
  213.         sprintf(buff, "*%s", SYM(a));
  214.     else
  215.         sprintf(buff, "%s", SYM(a));
  216.     return buff;
  217. }
  218.  
  219. /* disassemble one instruction at PC into buff. return byte size of instr */
  220. int Dasm2650(char * buff, int PC)
  221. {
  222.     int pc = PC;
  223.     int op = cpu_readop(pc);
  224.     int rv = op & 3;
  225.  
  226.     pc += 1;
  227.     switch (op)
  228.     {
  229.         case 0x00: case 0x01: case 0x02: case 0x03:
  230. #if HJB
  231.             sprintf(buff, "ld   r0,r%d", rv);
  232. #else
  233.             sprintf(buff, "lodz,%d", rv);
  234. #endif
  235.             break;
  236.         case 0x04: case 0x05: case 0x06: case 0x07:
  237. #if HJB
  238.             sprintf(buff, "ld   r%d,%s", rv, IMM(pc));
  239. #else
  240.             sprintf(buff, "lodi,%d %s", rv, IMM(pc));
  241. #endif
  242.             pc+=1;
  243.             break;
  244.         case 0x08: case 0x09: case 0x0a: case 0x0b:
  245. #if HJB
  246.             sprintf(buff, "ld   r%d,(%s)", rv, REL(pc));
  247. #else
  248.             sprintf(buff, "lodr,%d %s", rv, REL(pc));
  249. #endif
  250.             pc+=1;
  251.             break;
  252.         case 0x0c: case 0x0d: case 0x0e: case 0x0f:
  253. #if HJB
  254.             sprintf(buff, "ld   %s", ABS(1,rv,pc));
  255. #else
  256.             sprintf(buff, "loda,%s", ABS(1,rv,pc));
  257. #endif
  258.             pc+=2;
  259.             break;
  260.         case 0x10: case 0x11:
  261.             sprintf(buff, "****   %02X",op);
  262.             break;
  263.         case 0x12:
  264. #if HJB
  265.             sprintf(buff, "ld   psu,r0");
  266. #else
  267.             sprintf(buff, "spsu");
  268. #endif
  269.             break;
  270.         case 0x13:
  271. #if HJB
  272.             sprintf(buff, "ld   psl,r0");
  273. #else
  274.             sprintf(buff, "spsl");
  275. #endif
  276.             break;
  277.         case 0x14: case 0x15: case 0x16: case 0x17:
  278. #if HJB
  279.             if (rv == 3)
  280.                 sprintf(buff, "ret");
  281.             else
  282.                 sprintf(buff, "ret  %c", cc[rv]);
  283. #else
  284.             sprintf(buff, "retc   %c", cc[rv]);
  285. #endif
  286.             break;
  287.         case 0x18: case 0x19: case 0x1a: case 0x1b:
  288. #if HJB
  289.             if (rv == 3)
  290.                 sprintf(buff, "jr   %s", REL(pc));
  291.             else
  292.                 sprintf(buff, "jr   %c,%s", cc[rv], REL(pc));
  293. #else
  294.             sprintf(buff, "bctr,%c %s", cc[rv], REL(pc));
  295. #endif
  296.             pc+=1;
  297.             break;
  298.         case 0x1c: case 0x1d: case 0x1e: case 0x1f:
  299. #if HJB
  300.             if (rv == 3)
  301.                 sprintf(buff, "jp   %s", ADR(pc));
  302.             else
  303.                 sprintf(buff, "jp   %c,%s", cc[rv], ADR(pc));
  304. #else
  305.             sprintf(buff, "bcta,%c %s", cc[rv], ADR(pc));
  306. #endif
  307.             pc+=2;
  308.             break;
  309.         case 0x20: case 0x21: case 0x22: case 0x23:
  310. #if HJB
  311.             sprintf(buff, "xor  r0,r%d", rv);
  312. #else
  313.             sprintf(buff, "eorz,%d", rv);
  314. #endif
  315.             break;
  316.         case 0x24: case 0x25: case 0x26: case 0x27:
  317. #if HJB
  318.             sprintf(buff, "xor  r%d,%s", rv, IMM(pc));
  319. #else
  320.             sprintf(buff, "eori,%d %s", rv, IMM(pc));
  321. #endif
  322.             pc+=1;
  323.             break;
  324.         case 0x28: case 0x29: case 0x2a: case 0x2b:
  325. #if HJB
  326.             sprintf(buff, "xor  r%d,(%s)", rv, REL(pc));
  327. #else
  328.             sprintf(buff, "eorr,%d %s", rv, REL(pc));
  329. #endif
  330.             pc+=1;
  331.             break;
  332.         case 0x2c: case 0x2d: case 0x2e: case 0x2f:
  333. #if HJB
  334.             sprintf(buff, "xor  %s", ABS(1,rv,pc));
  335. #else
  336.             sprintf(buff, "eora,%s", ABS(1,rv,pc));
  337. #endif
  338.             pc+=2;
  339.             break;
  340.         case 0x30: case 0x31: case 0x32: case 0x33:
  341. #if HJB
  342.             sprintf(buff, "in   r%d,(ctl)", rv);
  343. #else
  344.             sprintf(buff, "redc,%d", rv);
  345. #endif
  346.             break;
  347.         case 0x34: case 0x35: case 0x36: case 0x37:
  348. #if HJB
  349.             if (rv == 3)
  350.                 sprintf(buff, "iret");
  351.             else
  352.                 sprintf(buff, "iret %c", cc[rv]);
  353. #else
  354.             sprintf(buff, "rete   %c", cc[rv]);
  355. #endif
  356.             break;
  357.         case 0x38: case 0x39: case 0x3a: case 0x3b:
  358. #if HJB
  359.             if (rv == 3)
  360.                 sprintf(buff, "calr %s", REL(pc));
  361.             else
  362.                 sprintf(buff, "calr %c,%s", cc[rv], REL(pc));
  363. #else
  364.             sprintf(buff, "bstr,%c %s", cc[rv], REL(pc));
  365. #endif
  366.             pc+=1;
  367.             break;
  368.         case 0x3c: case 0x3d: case 0x3e: case 0x3f:
  369. #if HJB
  370.             if (rv == 3)
  371.                 sprintf(buff, "call %s", ADR(pc));
  372.             else
  373.                 sprintf(buff, "call %c,%s", cc[rv], ADR(pc));
  374. #else
  375.             sprintf(buff, "bsta,%c %s", cc[rv], ADR(pc));
  376. #endif
  377.             pc+=2;
  378.             break;
  379.         case 0x40:
  380.             sprintf(buff, "halt");
  381.             break;
  382.         case 0x41: case 0x42: case 0x43:
  383. #if HJB
  384.             sprintf(buff, "and  r0,r%d", rv);
  385. #else
  386.             sprintf(buff, "andz,%d", rv);
  387. #endif
  388.             break;
  389.         case 0x44: case 0x45: case 0x46: case 0x47:
  390. #if HJB
  391.             sprintf(buff, "and  r%d,%s", rv, IMM(pc));
  392. #else
  393.             sprintf(buff, "andi,%d %s", rv, IMM(pc));
  394. #endif
  395.             pc+=1;
  396.             break;
  397.         case 0x48: case 0x49: case 0x4a: case 0x4b:
  398. #if HJB
  399.             sprintf(buff, "and  r%d,(%s)", rv, REL(pc));
  400. #else
  401.             sprintf(buff, "andr,%d %s", rv, REL(pc));
  402. #endif
  403.             pc+=1;
  404.             break;
  405.         case 0x4c: case 0x4d: case 0x4e: case 0x4f:
  406. #if HJB
  407.             sprintf(buff, "and  %s", ABS(1,rv,pc));
  408. #else
  409.             sprintf(buff, "anda,%s", ABS(1,rv,pc));
  410. #endif
  411.             pc+=2;
  412.             break;
  413.         case 0x50: case 0x51: case 0x52: case 0x53:
  414. #if HJB
  415.             sprintf(buff, "ror  r%d", rv);
  416. #else
  417.             sprintf(buff, "rrr,%d", rv);
  418. #endif
  419.             break;
  420.         case 0x54: case 0x55: case 0x56: case 0x57:
  421. #if HJB
  422.             sprintf(buff, "in   r%d,(%s)", rv, IMM(pc));
  423. #else
  424.             sprintf(buff, "rede,%d %s", rv, IMM(pc));
  425. #endif
  426.             pc+=1;
  427.             break;
  428.         case 0x58: case 0x59: case 0x5a: case 0x5b:
  429. #if HJB
  430.             sprintf(buff, "jrnz r%d,%s", rv, REL(pc));
  431. #else
  432.             sprintf(buff, "brnr,%d %s", rv, REL(pc));
  433. #endif
  434.             pc+=1;
  435.             break;
  436.         case 0x5c: case 0x5d: case 0x5e: case 0x5f:
  437. #if HJB
  438.             sprintf(buff, "jpnz r%d,%s", rv, ADR(pc));
  439. #else
  440.             sprintf(buff, "brna,%d %s", rv, ADR(pc));
  441. #endif
  442.             pc+=2;
  443.             break;
  444.         case 0x60: case 0x61: case 0x62: case 0x63:
  445. #if HJB
  446.             sprintf(buff, "or   r0,r%d", rv);
  447. #else
  448.             sprintf(buff, "iorz,%d", rv);
  449. #endif
  450.             break;
  451.         case 0x64: case 0x65: case 0x66: case 0x67:
  452. #if HJB
  453.             sprintf(buff, "or   r%d,%s", rv, IMM(pc));
  454. #else
  455.             sprintf(buff, "iori,%d %s", rv, IMM(pc));
  456. #endif
  457.             pc+=1;
  458.             break;
  459.         case 0x68: case 0x69: case 0x6a: case 0x6b:
  460. #if HJB
  461.             sprintf(buff, "or   r%d,(%s)", rv, REL(pc));
  462. #else
  463.             sprintf(buff, "iorr,%d %s", rv, REL(pc));
  464. #endif
  465.             pc+=1;
  466.             break;
  467.         case 0x6c: case 0x6d: case 0x6e: case 0x6f:
  468. #if HJB
  469.             sprintf(buff, "or   %s", ABS(1,rv,pc));
  470. #else
  471.             sprintf(buff, "iora,%s", ABS(1,rv,pc));
  472. #endif
  473.             pc+=2;
  474.             break;
  475.         case 0x70: case 0x71: case 0x72: case 0x73:
  476. #if HJB
  477.             sprintf(buff, "in   r%d,(data)", rv);
  478. #else
  479.             sprintf(buff, "redd,%d", rv);
  480. #endif
  481.             break;
  482.         case 0x74:
  483. #if HJB
  484.             sprintf(buff, "res  psu,%s", IMM_PSU(pc));
  485. #else
  486.             sprintf(buff, "cpsu   %s", IMM_PSU(pc));
  487. #endif
  488.             pc+=1;
  489.             break;
  490.         case 0x75:
  491. #if HJB
  492.             sprintf(buff, "res  psl,%s", IMM_PSL(pc));
  493. #else
  494.             sprintf(buff, "cpsl   %s", IMM_PSL(pc));
  495. #endif
  496.             pc+=1;
  497.             break;
  498.         case 0x76:
  499. #if HJB
  500.             sprintf(buff, "set  psu,%s", IMM_PSU(pc));
  501. #else
  502.             sprintf(buff, "ppsu   %s", IMM_PSU(pc));
  503. #endif
  504.             pc+=1;
  505.             break;
  506.         case 0x77:
  507. #if HJB
  508.             sprintf(buff, "set  psl,%s", IMM_PSL(pc));
  509. #else
  510.             sprintf(buff, "ppsl   %s", IMM_PSL(pc));
  511. #endif
  512.             pc+=1;
  513.             break;
  514.         case 0x78: case 0x79: case 0x7a: case 0x7b:
  515. #if HJB
  516.             sprintf(buff, "call r%d-nz,%s", rv, REL(pc));
  517. #else
  518.             sprintf(buff, "bsnr,%d %s", rv, REL(pc));
  519. #endif
  520.             pc+=1;
  521.             break;
  522.         case 0x7c: case 0x7d: case 0x7e: case 0x7f:
  523. #if HJB
  524.             sprintf(buff, "call r%d-nz,%s", rv, ADR(pc));
  525. #else
  526.             sprintf(buff, "bsna,%d %s", rv, ADR(pc));
  527. #endif
  528.             pc+=2;
  529.             break;
  530.         case 0x80: case 0x81: case 0x82: case 0x83:
  531. #if HJB
  532.             sprintf(buff, "add  r0,r%d", rv);
  533. #else
  534.             sprintf(buff, "addz,%d", rv);
  535. #endif
  536.             break;
  537.         case 0x84: case 0x85: case 0x86: case 0x87:
  538. #if HJB
  539.             sprintf(buff, "add  r%d,%s", rv, IMM(pc));
  540. #else
  541.             sprintf(buff, "addi,%d %s", rv, IMM(pc));
  542. #endif
  543.             pc+=1;
  544.             break;
  545.         case 0x88: case 0x89: case 0x8a: case 0x8b:
  546. #if HJB
  547.             sprintf(buff, "add  r%d,(%s)", rv, REL(pc));
  548. #else
  549.             sprintf(buff, "addr,%d %s", rv, REL(pc));
  550. #endif
  551.             pc+=1;
  552.             break;
  553.         case 0x8c: case 0x8d: case 0x8e: case 0x8f:
  554. #if HJB
  555.             sprintf(buff, "add  %s", ABS(1,rv,pc));
  556. #else
  557.             sprintf(buff, "adda,%s", ABS(1,rv,pc));
  558. #endif
  559.             pc+=2;
  560.             break;
  561.         case 0x90: case 0x91:
  562.             sprintf(buff, "****   %02X",op);
  563.             break;
  564.         case 0x92:
  565. #if HJB
  566.             sprintf(buff, "ld   r0,psu");
  567. #else
  568.             sprintf(buff, "lpsu");
  569. #endif
  570.             break;
  571.         case 0x93:
  572. #if HJB
  573.             sprintf(buff, "ld   r0,psl");
  574. #else
  575.             sprintf(buff, "lpsl");
  576. #endif
  577.             break;
  578.         case 0x94: case 0x95: case 0x96: case 0x97:
  579. #if HJB
  580.             sprintf(buff, "daa  r%d", rv);
  581. #else
  582.             sprintf(buff, "dar,%d", rv);
  583. #endif
  584.             break;
  585.         case 0x98: case 0x99: case 0x9a:
  586. #if HJB
  587.             sprintf(buff, "jr   n%c,%s", cc[rv], REL(pc));
  588. #else
  589.             sprintf(buff, "bcfr,%c %s", cc[rv], REL(pc));
  590. #endif
  591.             pc+=1;
  592.             break;
  593.         case 0x9b:
  594. #if HJB
  595.             sprintf(buff, "jr0  %s", REL0(pc));
  596. #else
  597.             sprintf(buff, "zbrr   %s", REL0(pc));
  598. #endif
  599.             pc+=1;
  600.             break;
  601.         case 0x9c: case 0x9d: case 0x9e:
  602. #if HJB
  603.             sprintf(buff, "jp   n%c,%s", cc[rv], ADR(pc));
  604. #else
  605.             sprintf(buff, "bcfa,%c %s", cc[rv], ADR(pc));
  606. #endif
  607.             pc+=2;
  608.             break;
  609.         case 0x9f:
  610. #if HJB
  611.             sprintf(buff, "jp   %s+r3", ADR(pc));
  612. #else
  613.             sprintf(buff, "bxa    %s", ADR(pc));
  614. #endif
  615.             pc+=2;
  616.             break;
  617.         case 0xa0: case 0xa1: case 0xa2: case 0xa3:
  618. #if HJB
  619.             sprintf(buff, "sub  r0,r%d", rv);
  620. #else
  621.             sprintf(buff, "subz,%d", rv);
  622. #endif
  623.             break;
  624.         case 0xa4: case 0xa5: case 0xa6: case 0xa7:
  625. #if HJB
  626.             sprintf(buff, "sub  r%d,%s", rv, IMM(pc));
  627. #else
  628.             sprintf(buff, "subi,%d %s", rv, IMM(pc));
  629. #endif
  630.             pc+=1;
  631.             break;
  632.         case 0xa8: case 0xa9: case 0xaa: case 0xab:
  633. #if HJB
  634.             sprintf(buff, "sub  r%d,(%s)", rv, REL(pc));
  635. #else
  636.             sprintf(buff, "subr,%d %s", rv, REL(pc));
  637. #endif
  638.             pc+=1;
  639.             break;
  640.         case 0xac: case 0xad: case 0xae: case 0xaf:
  641. #if HJB
  642.             sprintf(buff, "sub  %s", ABS(1,rv,pc));
  643. #else
  644.             sprintf(buff, "suba,%s", ABS(1,rv,pc));
  645. #endif
  646.             pc+=2;
  647.             break;
  648.         case 0xb0: case 0xb1: case 0xb2: case 0xb3:
  649. #if HJB
  650.             sprintf(buff, "out  (ctrl),r%d", rv);
  651. #else
  652.             sprintf(buff, "wrtc,%d", rv);
  653. #endif
  654.             break;
  655.         case 0xb4:
  656. #if HJB
  657.             sprintf(buff, "bit  psu,%s", IMM_PSU(pc));
  658. #else
  659.             sprintf(buff, "tpsu   %s", IMM_PSU(pc));
  660. #endif
  661.             pc+=1;
  662.             break;
  663.         case 0xb5:
  664. #if HJB
  665.             sprintf(buff, "bit  psl,%s", IMM_PSU(pc));
  666. #else
  667.             sprintf(buff, "tpsl   %s", IMM_PSL(pc));
  668. #endif
  669.             pc+=1;
  670.             break;
  671.         case 0xb6: case 0xb7:
  672.             sprintf(buff, "****   %02X", op);
  673.             break;
  674.         case 0xb8: case 0xb9: case 0xba:
  675. #if HJB
  676.             sprintf(buff, "calr n%c,%s", cc[rv], REL(pc));
  677. #else
  678.             sprintf(buff, "bsfr,%c %s", cc[rv], REL(pc));
  679. #endif
  680.             pc+=1;
  681.             break;
  682.         case 0xbb:
  683. #if HJB
  684.             sprintf(buff, "cal0 %s", REL0(pc));
  685. #else
  686.             sprintf(buff, "zbsr   %s", REL0(pc));
  687. #endif
  688.             pc+=1;
  689.             break;
  690.         case 0xbc: case 0xbd: case 0xbe:
  691. #if HJB
  692.             sprintf(buff, "call n%c,%s", cc[rv], ADR(pc));
  693. #else
  694.             sprintf(buff, "bsfa,%c %s", cc[rv], ADR(pc));
  695. #endif
  696.             pc+=2;
  697.             break;
  698.         case 0xbf:
  699. #if HJB
  700.             sprintf(buff, "call  %s+r3", ADR(pc));
  701. #else
  702.             sprintf(buff, "bsxa   %s", ADR(pc));
  703. #endif
  704.             pc+=2;
  705.             break;
  706.         case 0xc0:
  707.             sprintf(buff, "nop");
  708.             break;
  709.         case 0xc1: case 0xc2: case 0xc3:
  710. #if HJB
  711.             sprintf(buff, "ld   r%d,r0", rv);
  712. #else
  713.             sprintf(buff, "strz,%d", rv);
  714. #endif
  715.             break;
  716.         case 0xc4: case 0xc5: case 0xc6: case 0xc7:
  717.             sprintf(buff, "****   %02X", op);
  718.             break;
  719.         case 0xc8: case 0xc9: case 0xca: case 0xcb:
  720. #if HJB
  721.             sprintf(buff, "ld   (%s),r%d", REL(pc), rv);
  722. #else
  723.             sprintf(buff, "strr,%d %s", rv, REL(pc));
  724. #endif
  725.             pc+=1;
  726.             break;
  727.         case 0xcc: case 0xcd: case 0xce: case 0xcf:
  728. #if HJB
  729.             sprintf(buff, "ld   %s", ABS(0,rv,pc));
  730. #else
  731.             sprintf(buff, "stra,%s", ABS(1,rv,pc));
  732. #endif
  733.             pc+=2;
  734.             break;
  735.         case 0xd0: case 0xd1: case 0xd2: case 0xd3:
  736. #if HJB
  737.             sprintf(buff, "rol  r%d", rv);
  738. #else
  739.             sprintf(buff, "rrl,%d", rv);
  740. #endif
  741.             break;
  742.         case 0xd4: case 0xd5: case 0xd6: case 0xd7:
  743. #if HJB
  744.             sprintf(buff, "out r%d,(%s)", rv, IMM(pc));
  745. #else
  746.             sprintf(buff, "wrte,%d %s", rv, IMM(pc));
  747. #endif
  748.             pc+=1;
  749.             break;
  750.         case 0xd8: case 0xd9: case 0xda: case 0xdb:
  751. #if HJB
  752.             sprintf(buff, "ijnz r%d,%s", rv, REL(pc));
  753. #else
  754.             sprintf(buff, "birr,%d %s", rv, REL(pc));
  755. #endif
  756.             pc+=1;
  757.             break;
  758.         case 0xdc: case 0xdd: case 0xde: case 0xdf:
  759. #if HJB
  760.             sprintf(buff, "ijnz r%d,%s", rv, ADR(pc));
  761. #else
  762.             sprintf(buff, "bira,%d %s", rv, ADR(pc));
  763. #endif
  764.             pc+=2;
  765.             break;
  766.         case 0xe0: case 0xe1: case 0xe2: case 0xe3:
  767. #if HJB
  768.             sprintf(buff, "cp   r0,%d", rv);
  769. #else
  770.             sprintf(buff, "comz,%d", rv);
  771. #endif
  772.             break;
  773.         case 0xe4: case 0xe5: case 0xe6: case 0xe7:
  774. #if HJB
  775.             sprintf(buff, "cp   r%d,%s", rv, IMM(pc));
  776. #else
  777.             sprintf(buff, "comi,%d %s", rv, IMM(pc));
  778. #endif
  779.             pc+=1;
  780.             break;
  781.         case 0xe8: case 0xe9: case 0xea: case 0xeb:
  782. #if HJB
  783.             sprintf(buff, "cp   r%d,(%s)", rv, REL(pc));
  784. #else
  785.             sprintf(buff, "comr,%d %s", rv, REL(pc));
  786. #endif
  787.             pc+=1;
  788.             break;
  789.         case 0xec: case 0xed: case 0xee: case 0xef:
  790. #if HJB
  791.             sprintf(buff, "cp   %s", ABS(1,rv,pc));
  792. #else
  793.             sprintf(buff, "coma,%s", ABS(1,rv,pc));
  794. #endif
  795.             pc+=2;
  796.             break;
  797.         case 0xf0: case 0xf1: case 0xf2: case 0xf3:
  798. #if HJB
  799.             sprintf(buff, "out  (data),r%d", rv);
  800. #else
  801.             sprintf(buff, "wrtd,%d", rv);
  802. #endif
  803.             break;
  804.         case 0xf4: case 0xf5: case 0xf6: case 0xf7:
  805. #if HJB
  806.             sprintf(buff, "test r%d,%s", rv, IMM(pc));
  807. #else
  808.             sprintf(buff, "tmi,%d  %s", rv, IMM(pc));
  809. #endif
  810.             pc+=1;
  811.             break;
  812.         case 0xf8: case 0xf9: case 0xfa: case 0xfb:
  813. #if HJB
  814.             sprintf(buff, "djnz r%d,%s", rv, REL(pc));
  815. #else
  816.             sprintf(buff, "bdrr,%d %s", rv, REL(pc));
  817. #endif
  818.             pc+=1;
  819.             break;
  820.         case 0xfc: case 0xfd: case 0xfe: case 0xff:
  821. #if HJB
  822.             sprintf(buff, "djnz r%d,%s", rv, ADR(pc));
  823. #else
  824.             sprintf(buff, "bdra,%d %s", rv, ADR(pc));
  825. #endif
  826.             pc+=2;
  827.             break;
  828.     }
  829.     return pc - PC;
  830. }
  831.